package org.zxl.iotest.netty.protobuf.util;
public class ByteUtils {

    // 将 byte[] 转换为 int (大端序)
    public static int bytesToIntBE(byte[] bytes) {
        if (bytes == null || bytes.length != 4) {
            throw new IllegalArgumentException("Byte array must be 4 bytes long");
        }
        int value = 0;
        for (int i = 0; i < 4; i++) {
            value = (value << 8) | (bytes[i] & 0xFF);
        }
        return value;
    }

    // 将 byte[] 转换为 int (小端序)
    public static int bytesToIntLE(byte[] bytes) {
        if (bytes == null || bytes.length != 4) {
            throw new IllegalArgumentException("Byte array must be 4 bytes long");
        }
        int value = 0;
        for (int i = 0; i < 4; i++) {
            value |= (bytes[i] & 0xFF) << (i * 8);
        }
        return value;
    }

    // 将 byte[] 转换为 short (大端序)
    public static short bytesToShortBE(byte[] bytes) {
        if (bytes == null || bytes.length != 2) {
            throw new IllegalArgumentException("Byte array must be 2 bytes long");
        }
        short value = 0;
        for (int i = 0; i < 2; i++) {
            value = (short) ((value << 8) | (bytes[i] & 0xFF));
        }
        return value;
    }

    // 将 byte[] 转换为 short (小端序)
    public static short bytesToShortLE(byte[] bytes) {
        if (bytes == null || bytes.length != 2) {
            throw new IllegalArgumentException("Byte array must be 2 bytes long");
        }
        short value = 0;
        for (int i = 0; i < 2; i++) {
            value |= (bytes[i] & 0xFF) << (i * 8);
        }
        return value;
    }

    // 将 int 转换为 byte[] (大端序)
    public static byte[] intToBytesBE(int value) {
        byte[] bytes = new byte[4];
        for (int i = 3; i >= 0; i--) {
            bytes[i] = (byte) (value & 0xFF);
            value >>= 8;
        }
        return bytes;
    }

    // 将 int 转换为 byte[] (小端序)
    public static byte[] intToBytesLE(int value) {
        byte[] bytes = new byte[4];
        for (int i = 0; i < 4; i++) {
            bytes[i] = (byte) (value & 0xFF);
            value >>= 8;
        }
        return bytes;
    }

    // 将 short 转换为 byte[] (大端序)
    public static byte[] shortToBytesBE(short value) {
        byte[] bytes = new byte[2];
        for (int i = 1; i >= 0; i--) {
            bytes[i] = (byte) (value & 0xFF);
            value >>= 8;
        }
        return bytes;
    }

    // 将 short 转换为 byte[] (小端序)
    public static byte[] shortToBytesLE(short value) {
        byte[] bytes = new byte[2];
        for (int i = 0; i < 2; i++) {
            bytes[i] = (byte) (value & 0xFF);
            value >>= 8;
        }
        return bytes;
    }

    // 将 byte[] 转换为 long (大端序)
    public static long bytesToLongBE(byte[] bytes) {
        if (bytes == null || bytes.length != 8) {
            throw new IllegalArgumentException("Byte array must be 8 bytes long");
        }
        long value = 0;
        for (int i = 0; i < 8; i++) {
            value = (value << 8) | (bytes[i] & 0xFF);
        }
        return value;
    }

    // 将 byte[] 转换为 long (小端序)
    public static long bytesToLongLE(byte[] bytes) {
        if (bytes == null || bytes.length != 8) {
            throw new IllegalArgumentException("Byte array must be 8 bytes long");
        }
        long value = 0;
        for (int i = 0; i < 8; i++) {
            value |= (bytes[i] & 0xFFL) << (i * 8);
        }
        return value;
    }

    // 将 long 转换为 byte[] (大端序)
    public static byte[] longToBytesBE(long value) {
        byte[] bytes = new byte[8];
        for (int i = 7; i >= 0; i--) {
            bytes[i] = (byte) (value & 0xFF);
            value >>= 8;
        }
        return bytes;
    }

    // 将 long 转换为 byte[] (小端序)
    public static byte[] longToBytesLE(long value) {
        byte[] bytes = new byte[8];
        for (int i = 0; i < 8; i++) {
            bytes[i] = (byte) (value & 0xFF);
            value >>= 8;
        }
        return bytes;
    }

    public static void main(String[] args) {
        // 示例：将 byte[] 转换为 int (大端序)
        byte[] intBytesBE = {0x00, 0x00, 0x01, 0x00};
        int intValueBE = bytesToIntBE(intBytesBE);
        System.out.println("Int value (BE): " + intValueBE); // 输出: Int value (BE): 256

        // 示例：将 byte[] 转换为 int (小端序)
        byte[] intBytesLE = {0x00, 0x01, 0x00, 0x00};
        int intValueLE = bytesToIntLE(intBytesLE);
        System.out.println("Int value (LE): " + intValueLE); // 输出: Int value (LE): 256

        // 示例：将 byte[] 转换为 short (大端序)
        byte[] shortBytesBE = {0x01, 0x00};
        short shortValueBE = bytesToShortBE(shortBytesBE);
        System.out.println("Short value (BE): " + shortValueBE); // 输出: Short value (BE): 256

        // 示例：将 byte[] 转换为 short (小端序)
        byte[] shortBytesLE = {0x00, 0x01};
        short shortValueLE = bytesToShortLE(shortBytesLE);
        System.out.println("Short value (LE): " + shortValueLE); // 输出: Short value (LE): 256

        // 示例：将 int 转换为 byte[] (大端序)
        int intValue = 256;
        byte[] intBytesBEConverted = intToBytesBE(intValue);
        for (byte b : intBytesBEConverted) {
            System.out.printf("%02X ", b);
        }
        System.out.println(); // 输出: 00 00 01 00

        // 示例：将 int 转换为 byte[] (小端序)
        byte[] intBytesLEConverted = intToBytesLE(intValue);
        for (byte b : intBytesLEConverted) {
            System.out.printf("%02X ", b);
        }
        System.out.println(); // 输出: 00 01 00 00

        // 示例：将 short 转换为 byte[] (大端序)
        short shortValue = 256;
        byte[] shortBytesBEConverted = shortToBytesBE(shortValue);
        for (byte b : shortBytesBEConverted) {
            System.out.printf("%02X ", b);
        }
        System.out.println(); // 输出: 01 00

        // 示例：将 short 转换为 byte[] (小端序)
        byte[] shortBytesLEConverted = shortToBytesLE(shortValue);
        for (byte b : shortBytesLEConverted) {
            System.out.printf("%02X ", b);
        }
        System.out.println(); // 输出: 00 01

        // 示例：将 byte[] 转换为 long (大端序)
        byte[] longBytesBE = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00};
        long longValueBE = bytesToLongBE(longBytesBE);
        System.out.println("Long value (BE): " + longValueBE); // 输出: Long value (BE): 65536

        // 示例：将 byte[] 转换为 long (小端序)
        byte[] longBytesLE = {0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
        long longValueLE = bytesToLongLE(longBytesLE);
        System.out.println("Long value (LE): " + longValueLE); // 输出: Long value (LE): 65536

        // 示例：将 long 转换为 byte[] (大端序)
        long longValue = 65536;
        byte[] longBytesBEConverted = longToBytesBE(longValue);
        for (byte b : longBytesBEConverted) {
            System.out.printf("%02X ", b);
        }
        System.out.println(); // 输出: 00 00 00 00 00 01 00 00

        // 示例：将 long 转换为 byte[] (小端序)
        byte[] longBytesLEConverted = longToBytesLE(longValue);
        for (byte b : longBytesLEConverted) {
            System.out.printf("%02X ", b);
        }
        System.out.println(); // 输出: 00 01 00 00 00 00 00 00
    }
    public static byte[] concatenateByteArrays(byte[]... arrays) {
        int totalLength = 0;
        for (byte[] array : arrays) {
            totalLength += array.length;
        }

        byte[] result = new byte[totalLength];
        int offset = 0;
        for (byte[] array : arrays) {
            System.arraycopy(array, 0, result, offset, array.length);
            offset += array.length;
        }
        return result;
    }
}


